Update stack filter to work with tracks and routes too

diff --git a/gpsbabel/defs.h b/gpsbabel/defs.h
index d763000c0076e4f5400c04bd6e6b304d651d9e43..790e09230eba8a9b863a5022c0715a9e5f96e3cd 100644 (file)
--- a/gpsbabel/defs.h
+++ b/gpsbabel/defs.h
@@ -402,10 +402,14 @@ route_head * route_find_track_by_name(const char *name);
 unsigned int route_waypt_count(void);
 unsigned int route_count(void);
 unsigned int track_count(void);
+void route_copy( int *dst_count, int *dst_wpt_count, queue **dst, queue *src );
 void route_backup(signed int *count, queue **head_bak);
-void route_restore(signed int count, queue *head_bak);
+void route_restore( queue *head_bak);
+void route_append( queue *src );
 void track_backup(signed int *count, queue **head_bak);
-void track_restore(signed int count, queue *head_bak);
+void track_restore( queue *head_bak);
+void track_append( queue *src );
+void route_flush( queue *head );
 
 /*
  * All shortname functions take a shortname handle as the first arg.

diff --git a/gpsbabel/main.c b/gpsbabel/main.c
index 540b09d07113902cf686eecf7133a8a1fd1bad60..7eb25e18731c9c16e5c81d8f85be3ffc418c418f 100644 (file)
--- a/gpsbabel/main.c
+++ b/gpsbabel/main.c
@@ -215,6 +215,7 @@ main(int argc, char *argv[])
                                        wpt_ct_bak = -1;
                                        rte_ct_bak = -1;
                                        trk_ct_bak = -1;
+                                       rte_head_bak = trk_head_bak = NULL;
 
                                        ovecs->wr_init(ofname);
 
@@ -242,8 +243,14 @@ main(int argc, char *argv[])
                                        cet_convert_deinit();
                                        
                                        if (wpt_ct_bak != -1) waypt_restore(wpt_ct_bak, wpt_head_bak);
-                                       if (rte_ct_bak != -1) route_restore(rte_ct_bak, rte_head_bak);
-                                       if (trk_ct_bak != -1) track_restore(trk_ct_bak, trk_head_bak);
+                                       if (rte_ct_bak != -1) {
+                                               route_restore( rte_head_bak);
+                                               xfree( rte_head_bak );
+                                       }
+                                       if (trk_ct_bak != -1) {
+                                               track_restore( trk_head_bak);
+                                               xfree( trk_head_bak );
+                                       }
                                }
                                break;
                        case 's':

diff --git a/gpsbabel/route.c b/gpsbabel/route.c
index db322b05c8d4e26c674f970bbd93793da505209e..9c75289dbb12075bb91ef155de4b96bbd5ea10e1 100644 (file)
--- a/gpsbabel/route.c
+++ b/gpsbabel/route.c
@@ -62,38 +62,63 @@ route_head_alloc(void)
 }
 
 
+void
+any_route_add_head( route_head *rte, queue *head ) {
+        ENQUEUE_TAIL( head, &rte->Q );
+        QUEUE_INIT(&rte->waypoint_list);
+}
+
+void
+any_route_del_head( route_head *rte ) {
+       dequeue( &rte->Q );
+       route_free( rte );
+}
+
 void
 route_add_head(route_head *rte)
 {
-       ENQUEUE_TAIL(&my_route_head, &rte->Q);
-       QUEUE_INIT(&rte->waypoint_list);
+       any_route_add_head( rte, &my_route_head );
        rte_head_ct++;
 }
 
 void
 route_del_head(route_head *rte)
 {
-       dequeue( &rte->Q );
-       route_free( rte );
+       any_route_del_head( rte );
        rte_head_ct--;
 }
 
 void
 track_add_head(route_head *rte)
 {
-       ENQUEUE_TAIL(&my_track_head, &rte->Q);
-       QUEUE_INIT(&rte->waypoint_list);
+       any_route_add_head( rte, &my_track_head );
        trk_head_ct++;
 }
 
 void
 track_del_head(route_head *rte)
 {
-       dequeue( &rte->Q );
-       route_free( rte );
+       any_route_del_head( rte );
        trk_head_ct--;
 }
 
+void
+route_debug_count( char *str, queue *q )
+{
+       queue *elem, *tmp;
+       int count = 0;
+       QUEUE_FOR_EACH( q, elem, tmp ) {
+               count++;
+       }
+       fprintf( stderr, "%s %d\n", str, count );
+}
+
+void 
+route_debug_count_main( char *str ) 
+{
+       route_debug_count( str, &my_route_head );
+}
+
 static 
 route_head *
 common_route_by_name(queue *routes, const char *name)
@@ -124,19 +149,25 @@ route_find_track_by_name(const char *name)
 }
 
 void
-route_add_wpt(route_head *rte, waypoint *wpt)
+any_route_add_wpt(route_head *rte, waypoint *wpt, int *ct )
 {
        ENQUEUE_TAIL(&rte->waypoint_list, &wpt->Q);
        rte->rte_waypt_ct++;    /* waypoints in this route */
-       rte_waypts++;           /* total waypoints in all routes */
+       (*ct)++;
        if (wpt->shortname == NULL) {
                char tmpnam[10];
-               snprintf(tmpnam, sizeof(tmpnam), "RPT%03d",rte_waypts);
+               snprintf(tmpnam, sizeof(tmpnam), "RPT%03d",*ct);
                wpt->shortname = xstrdup(tmpnam);
                wpt->wpt_flags.shortname_is_synthetic = 1;
        }
 }
 
+void 
+route_add_wpt( route_head *rte, waypoint *wpt )
+{
+       any_route_add_wpt( rte, wpt, &rte_waypts );
+}
+
 waypoint *
 route_find_waypt_by_name( route_head *rh, const char *name )
 {
@@ -152,16 +183,22 @@ route_find_waypt_by_name( route_head *rh, const char *name )
 }
 
 void 
-route_del_wpt( route_head *rte, waypoint *wpt)
+any_route_del_wpt( route_head *rte, waypoint *wpt, int *ct)
 {
        dequeue( &wpt->Q );
        waypt_free( wpt );
        rte->rte_waypt_ct--;
-       rte_waypts--;
+       (*ct)--;
+}
+
+void 
+route_del_wpt( route_head *rte, waypoint *wpt )
+{
+       any_route_del_wpt( rte, wpt, &rte_waypts );
 }
 
 void
-route_free(route_head *rte)
+any_route_free(route_head *rte)
 {
        if ( rte->rte_name ) {
                xfree(rte->rte_name);
@@ -169,7 +206,6 @@ route_free(route_head *rte)
        if ( rte->rte_desc ) {
                xfree(rte->rte_desc);
        }
-       rte_waypts -= rte->rte_waypt_ct;
        waypt_flush(&rte->waypoint_list);
        if ( rte->fs ) {
                fs_chain_destroy( rte->fs );
@@ -177,6 +213,12 @@ route_free(route_head *rte)
        xfree(rte);
 }
 
+void route_free( route_head *rte )
+{
+       any_route_free( rte );
+       rte_waypts -= rte->rte_waypt_ct;
+}
+
 void
 route_disp (const route_head *rh, waypt_cb cb )
 {
@@ -262,48 +304,68 @@ route_flush_all()
        route_flush_all_routes();
 }
 
-void
-route_backup(signed int *count, queue **head_bak)
+void 
+route_flush( queue *head ) 
 {
+       queue *elem, *tmp;
+       queue *q;
+        QUEUE_FOR_EACH(head, elem, tmp ) {
+               q = dequeue(elem);
+               any_route_free((route_head *)q);
+       }
+}
+
+void
+route_copy( int *dst_count, int *dst_wpt_count, queue **dst, queue *src ) {
        queue *elem, *tmp, *elem2, *tmp2;
-       queue *qbackup;
        route_head *rte_new;
-       unsigned int no;
-
-       no = route_count();
-       
-       qbackup = xcalloc(1, sizeof(*qbackup));
-       QUEUE_INIT(qbackup);
-       
-       QUEUE_MOVE(qbackup, &my_route_head);
-       QUEUE_INIT(&my_route_head);
-       
-       rte_head_ct = 0;
-       rte_waypts = 0;
+       int junk;
+       if ( !dst_wpt_count ) {
+               dst_wpt_count = &junk;
+       }
        
-       QUEUE_FOR_EACH(qbackup, elem, tmp)
+        if ( !*dst ) {
+               *dst = xcalloc( 1, sizeof( queue ));
+               QUEUE_INIT( *dst );
+               *dst_count = 0;
+               *dst_wpt_count = 0;
+       }
+       QUEUE_FOR_EACH(src, elem, tmp )
        {
-           route_head *rte_old = (route_head *)elem;
-           
-           rte_new = route_head_alloc();
-           if (rte_old->rte_name != NULL)
-               rte_new->rte_name = xstrdup(rte_old->rte_name);
-           if (rte_old->rte_desc != NULL)
-               rte_new->rte_desc = xstrdup(rte_old->rte_desc);
-           if (rte_old->fs)
-               rte_new->fs = fs_chain_copy(rte_old->fs);
-
-           route_add_head(rte_new);
-           rte_new->rte_num = rte_old->rte_num;
-           
-           QUEUE_FOR_EACH(&rte_old->waypoint_list, elem2, tmp2)
-           {
-               waypoint *wpt = waypt_dupe((waypoint *)elem2);
-               route_add_wpt(rte_new, wpt);
-           }
+               route_head *rte_old = (route_head *)elem;
+               
+               rte_new = route_head_alloc();
+               rte_new->rte_name = xstrdup( rte_old->rte_name );
+               rte_new->rte_desc = xstrdup( rte_old->rte_desc );
+               rte_new->fs = fs_chain_copy( rte_old->fs );
+               rte_new->rte_num = rte_old->rte_num;
+               any_route_add_head( rte_new, *dst );
+               QUEUE_FOR_EACH( &rte_old->waypoint_list, elem2, tmp2 ) 
+               {
+                       any_route_add_wpt( rte_new, waypt_dupe((waypoint *)elem2), dst_wpt_count);
+               }
+               (*dst_count)++;
        }
-       *head_bak = qbackup;
-       *count = no;
+}
+
+void
+route_append( queue *src ) 
+{
+       queue *dst = &my_route_head;
+       route_copy( &rte_head_ct, &rte_waypts, &dst, src );
+}
+
+void
+track_append( queue *src )
+{
+       queue *dst = &my_track_head;
+       route_copy( &trk_head_ct, NULL, &dst, src );
+}
+
+void
+route_backup(signed int *count, queue **head_bak)
+{
+       route_copy( count, NULL, head_bak, &my_route_head );
 }
 
 static void
@@ -329,6 +391,11 @@ route_restore_wpt(const waypoint *wpt)
        rte_waypts++;
 }
 
+static void
+track_restore_wpt(const waypoint *wpt)
+{
+}
+
 void
 common_restore_finish(void)
 {
@@ -336,18 +403,17 @@ common_restore_finish(void)
        trk_head_ct = 0;
        rte_waypts = 0;
        route_disp_all(route_restore_hdr, route_restore_tlr, route_restore_wpt);
-       track_disp_all(track_restore_hdr, route_restore_tlr, route_restore_wpt);
+       track_disp_all(track_restore_hdr, route_restore_tlr, track_restore_wpt);
 }
 
 void
-route_restore(signed int count, queue *head_bak)
+route_restore( queue *head_bak)
 {
        if (head_bak == NULL) return;
        
        route_flush_q(&my_route_head);
        QUEUE_INIT(&my_route_head);
        QUEUE_MOVE(&my_route_head, head_bak);
-       xfree(head_bak);
        
        common_restore_finish();
 }
@@ -355,55 +421,17 @@ route_restore(signed int count, queue *head_bak)
 void
 track_backup(signed int *count, queue **head_bak)
 {
-       queue *elem, *tmp, *elem2, *tmp2;
-       queue *qbackup;
-       route_head *trk_new;
-       unsigned int no;
-       
-       no = track_count();
-       
-       qbackup = xcalloc(1, sizeof(*qbackup));
-       QUEUE_INIT(qbackup);
-       
-       QUEUE_MOVE(qbackup, &my_track_head);
-       QUEUE_INIT(&my_track_head);
-       
-       trk_head_ct = 0;
-       
-       QUEUE_FOR_EACH(qbackup, elem, tmp)
-       {
-           route_head *trk_old = (route_head *)elem;
-           
-           trk_new = route_head_alloc();
-           if (trk_old->rte_name != NULL)
-               trk_new->rte_name = xstrdup(trk_old->rte_name);
-           if (trk_old->rte_desc != NULL)
-               trk_new->rte_desc = xstrdup(trk_old->rte_desc);
-           if (trk_old->fs)
-               trk_new->fs = fs_chain_copy(trk_old->fs);
-
-           track_add_head(trk_new);
-           trk_new->rte_num = trk_old->rte_num;
-           
-           QUEUE_FOR_EACH(&trk_old->waypoint_list, elem2, tmp2)
-           {
-               waypoint *wpt = waypt_dupe((waypoint *)elem2);
-               route_add_wpt(trk_new, wpt);
-           }
-       }
-       *head_bak = qbackup;
-       *count = no;
+       route_copy( count, NULL, head_bak, &my_track_head );
 }
 
 void
-track_restore(signed int count, queue *head_bak)
+track_restore( queue *head_bak)
 {
        if (head_bak == NULL) return;
        
        route_flush_q(&my_track_head);
        QUEUE_INIT(&my_track_head);
        QUEUE_MOVE(&my_track_head, head_bak);
-       xfree(head_bak);
        
        common_restore_finish();
 }

diff --git a/gpsbabel/stackfilter.c b/gpsbabel/stackfilter.c
index cc4779284fab75f4ed6e7b65ccd1608d74b5254b..fcbd86327a2fdc6588d3155514e04cf7b7787a68 100644 (file)
--- a/gpsbabel/stackfilter.c
+++ b/gpsbabel/stackfilter.c
@@ -61,7 +61,11 @@ arglist_t stackfilt_args[] = {
 
 struct stack_elt {
        queue waypts;
+        queue routes;
+        queue tracks;  
        unsigned int waypt_ct;
+       int route_count;
+       int track_count;
        struct stack_elt *next;
 } *stack = NULL;
 
@@ -77,6 +81,7 @@ stackfilt_process(void)
        
        if ( opt_push ) {
                tmp_elt = (struct stack_elt *)xmalloc(sizeof(struct stack_elt));
+               
                QUEUE_MOVE(&(tmp_elt->waypts), &waypt_head);
                tmp_elt->waypt_ct = waypt_count();
                set_waypt_count(0);
@@ -87,6 +92,21 @@ stackfilt_process(void)
                                waypt_add( waypt_dupe((waypoint *)elem));
                        }
                }       
+               
+               tmp = NULL;
+               route_backup( &(tmp_elt->route_count), &tmp );
+               QUEUE_MOVE( &(tmp_elt->routes), tmp );
+               if ( !opt_copy ) {
+                       route_flush_all_routes();
+               }
+               
+               tmp = NULL;
+               track_backup( &(tmp_elt->track_count), &tmp );
+               QUEUE_MOVE( &(tmp_elt->tracks), tmp );
+               if ( !opt_copy ) {
+                       route_flush_all_tracks();
+               }
+               
        }
        else if ( opt_pop ) { 
                tmp_elt = stack;
@@ -97,15 +117,25 @@ stackfilt_process(void)
                        QUEUE_FOR_EACH( &(stack->waypts), elem, tmp ) {
                                waypt_add( (waypoint *)elem);
                        }
+                       route_append( &(stack->routes));
+                       route_flush( &(stack->routes));
+                       track_append( &(stack->tracks));
+                       route_flush( &(stack->tracks));
                }
                else if ( opt_discard ) {
-                       waypt_flush( &(stack->waypts) );
+                       waypt_flush( &(stack->waypts));
+                       route_flush( &(stack->routes));
+                       route_flush( &(stack->tracks));
                }
                else {
                        waypt_flush( &waypt_head );
                        QUEUE_MOVE(&(waypt_head), &(stack->waypts) );
                        set_waypt_count(stack->waypt_ct);
-               }
+                       
+                       route_restore( &(stack->routes));
+                       track_restore( &(stack->tracks));
+               } 
+
                stack = tmp_elt->next;
                xfree( tmp_elt );
        }
@@ -122,6 +152,18 @@ stackfilt_process(void)
                QUEUE_MOVE(&(tmp_elt->waypts), &waypt_head );
                QUEUE_MOVE(&waypt_head, &tmp_queue );
                
+               QUEUE_MOVE(&tmp_queue, &(tmp_elt->routes));
+               tmp = NULL;
+               route_backup( &(tmp_elt->route_count), &tmp);
+               QUEUE_MOVE(&(tmp_elt->routes), tmp );
+               route_restore( &tmp_queue );
+               
+               QUEUE_MOVE(&tmp_queue, &(tmp_elt->tracks));
+               tmp = NULL;
+               track_backup( &(tmp_elt->track_count), &tmp);
+               QUEUE_MOVE(&(tmp_elt->tracks), tmp );
+               track_restore( &tmp_queue );
+               
                tmp_count = waypt_count();
                set_waypt_count( tmp_elt->waypt_ct );
                tmp_elt->waypt_ct = tmp_count;